home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / M2Crypto / PGP / packet.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  13KB  |  411 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import struct
  5. import time
  6.  
  7. try:
  8.     from cStringIO import StringIO
  9. except ImportError:
  10.     from StringIO import StringIO
  11.  
  12. from M2Crypto import EVP, RSA
  13. from M2Crypto.util import octx_to_num
  14. from constants import *
  15. _OK_VERSION = ('\x02', '\x03')
  16. _OK_VALIDITY = ('\x00',)
  17. _OK_PKC = ('\x01',)
  18.  
  19. class packet:
  20.     
  21.     def __init__(self, ctb, body = None):
  22.         self.ctb = ctb
  23.         if body is not None:
  24.             self.body = StringIO(body)
  25.         else:
  26.             self.body = None
  27.  
  28.     
  29.     def validate(self):
  30.         return 1
  31.  
  32.     
  33.     def pack(self):
  34.         raise NotImplementedError, '%s.pack(): abstract method' % (self.__class__,)
  35.  
  36.     
  37.     def version(self):
  38.         if hasattr(self, '_version'):
  39.             return ord(self._version)
  40.         else:
  41.             return None
  42.  
  43.     
  44.     def timestamp(self):
  45.         if hasattr(self, '_timestamp'):
  46.             return struct.unpack('>L', self._timestamp)[0]
  47.         else:
  48.             return None
  49.  
  50.     
  51.     def validity(self):
  52.         if hasattr(self, '_validity'):
  53.             return struct.unpack('>H', self._validity)[0]
  54.         else:
  55.             return None
  56.  
  57.     
  58.     def pkc(self):
  59.         if hasattr(self, '_pkc'):
  60.             return self._pkc
  61.         else:
  62.             return None
  63.  
  64.     
  65.     def _llf(self, lenf):
  66.         if lenf < 256:
  67.             return (0, chr(lenf))
  68.         elif lenf < 65536:
  69.             return (1, struct.pack('>H', lenf))
  70.         else:
  71.             return (2, struct.pack('>L', lenf))
  72.  
  73.     
  74.     def _ctb(self, llf):
  75.         ctbv = _FACTORY[self.__class__]
  76.         return chr(128 | ctbv << 2 | llf)
  77.  
  78.  
  79.  
  80. class public_key_packet(packet):
  81.     
  82.     def __init__(self, ctb, body = None):
  83.         packet.__init__(self, ctb, body)
  84.         if self.body is not None:
  85.             self._version = self.body.read(1)
  86.             self._timestamp = self.body.read(4)
  87.             self._validity = self.body.read(2)
  88.             self._pkc = self.body.read(1)
  89.             self._nlen = self.body.read(2)
  90.             nlen = (struct.unpack('>H', self._nlen)[0] + 7) / 8
  91.             self._n = self.body.read(nlen)
  92.             self._elen = self.body.read(2)
  93.             elen = (struct.unpack('>H', self._elen)[0] + 7) / 8
  94.             self._e = self.body.read(elen)
  95.         
  96.  
  97.     
  98.     def pack(self):
  99.         if self.body is None:
  100.             self.body = StringIO()
  101.             self.body.write(self._version)
  102.             self.body.write(self._timestamp)
  103.             self.body.write(self._validity)
  104.             self.body.write(self._pkc)
  105.             self.body.write(self._nlen)
  106.             self.body.write(self._n)
  107.             self.body.write(self._elen)
  108.             self.body.write(self._e)
  109.         
  110.         self.body = self.body.getvalue()
  111.         (llf, lenf) = self._llf(len(self.body))
  112.         ctb = self._ctb(llf)
  113.         return '%s%s%s' % (ctb, lenf, self.body)
  114.  
  115.     
  116.     def pubkey(self):
  117.         return self._pubkey.pub()
  118.  
  119.  
  120.  
  121. class trust_packet(packet):
  122.     
  123.     def __init__(self, ctb, body = None):
  124.         packet.__init__(self, ctb, body)
  125.         if body is not None:
  126.             self.trust = self.body.read(1)
  127.         
  128.  
  129.  
  130.  
  131. class userid_packet(packet):
  132.     
  133.     def __init__(self, ctb, body = None):
  134.         packet.__init__(self, ctb, body)
  135.         if body is not None:
  136.             self._userid = body
  137.         
  138.  
  139.     
  140.     def pack(self):
  141.         if self.body is None:
  142.             self.body = StringIO()
  143.             self.body.write(chr(len(self._userid)))
  144.             self.body.write(self._userid)
  145.             self.body = self.body.getvalue()
  146.         
  147.         return self.ctb + self.body
  148.  
  149.     
  150.     def userid(self):
  151.         return self._userid
  152.  
  153.  
  154.  
  155. class comment_packet(packet):
  156.     
  157.     def __init__(self, ctb, body = None):
  158.         packet.__init__(self, ctb, body)
  159.         if body is not None:
  160.             self.comment = self.body.getvalue()
  161.         
  162.  
  163.     
  164.     def pack(self):
  165.         if self.body is None:
  166.             self.body = StringIO()
  167.             self.body.write(chr(len(self.comment)))
  168.             self.body.write(self.comment)
  169.             self.body = self.body.getvalue()
  170.         
  171.         return self.ctb + self.body
  172.  
  173.  
  174.  
  175. class signature_packet(packet):
  176.     
  177.     def __init__(self, ctb, body = None):
  178.         packet.__init__(self, ctb, body)
  179.         if body is not None:
  180.             self._version = self.body.read(1)
  181.             self._len_md_stuff = self.body.read(1)
  182.             self._classification = self.body.read(1)
  183.             self._timestamp = self.body.read(4)
  184.             self._keyid = self.body.read(8)
  185.             self._pkc = self.body.read(1)
  186.             self._md_algo = self.body.read(1)
  187.             self._md_chksum = self.body.read(2)
  188.             self._sig = self.body.read()
  189.         
  190.  
  191.     
  192.     def pack(self):
  193.         if self.body is None:
  194.             self.body = StringIO()
  195.             self.body.write(self._version)
  196.             self.body.write(self._len_md_stuff)
  197.             self.body.write(self._classification)
  198.             self.body.write(self._timestamp)
  199.             self.body.write(self._keyid)
  200.             self.body.write(self._pkc)
  201.             self.body.write(self._md_algo)
  202.             self.body.write(self._md_chksum)
  203.             self.body.write(self._sig)
  204.             self.body = self.body.getvalue()
  205.         
  206.         (llf, lenf) = self._llf(len(body))
  207.         self.ctb = self.ctb | llf
  208.         return '%s%s%s' % (self.ctb, lenf, self.body)
  209.  
  210.     
  211.     def validate(self):
  212.         if self._version not in _OK_VERSION:
  213.             return None
  214.         
  215.         if self._len_md_stuff != '\x05':
  216.             return None
  217.         
  218.  
  219.  
  220.  
  221. class private_key_packet(packet):
  222.     
  223.     def __init__(self, ctb, body = None):
  224.         packet.__init__(self, ctb, body)
  225.         if body is not None:
  226.             self._version = self.body.read(1)
  227.             self._timestamp = self.body.read(4)
  228.             self._validity = self.body.read(2)
  229.             self._pkc = self.body.read(1)
  230.             self._nlen = self.body.read(2)
  231.             nlen = (struct.unpack('>H', self._nlen)[0] + 7) / 8
  232.             self._n = self.body.read(nlen)
  233.             self._elen = self.body.read(2)
  234.             elen = (struct.unpack('>H', self._elen)[0] + 7) / 8
  235.             self._e = self.body.read(elen)
  236.             self._cipher = self.body.read(1)
  237.             if self._cipher == '\x01':
  238.                 self._iv = self.body.read(8)
  239.             else:
  240.                 self._iv = None
  241.             for param in [
  242.                 'd',
  243.                 'p',
  244.                 'q',
  245.                 'u']:
  246.                 _plen = self.body.read(2)
  247.                 setattr(self, '_' + param + 'len', _plen)
  248.                 plen = (struct.unpack('>H', _plen)[0] + 7) / 8
  249.                 setattr(self, '_' + param, self.body.read(plen))
  250.             
  251.             self._cksum = self.body.read(2)
  252.         
  253.  
  254.     
  255.     def is_encrypted(self):
  256.         return ord(self._cipher)
  257.  
  258.  
  259.  
  260. class cke_packet(packet):
  261.     
  262.     def __init__(self, ctb, body = None):
  263.         packet.__init__(self, ctb, body)
  264.         if body is not None:
  265.             self._iv = self.body.read(8)
  266.             self._cksum = self.body.read(2)
  267.             self._ctxt = self.body.read()
  268.         
  269.  
  270.  
  271.  
  272. class pke_packet(packet):
  273.     
  274.     def __init__(self, ctb, body = None):
  275.         packet.__init__(self, ctb, body)
  276.         if body is not None:
  277.             self._version = self.body.read(1)
  278.             self._keyid = self.body.read(8)
  279.             self._pkc = ord(self.body.read(1))
  280.             deklen = (struct.unpack('>H', self.body.read(2))[0] + 7) / 8
  281.             self._dek = octx_to_num(self.body.read(deklen))
  282.         
  283.  
  284.  
  285.  
  286. class literal_packet(packet):
  287.     
  288.     def __init__(self, ctb, body = None):
  289.         packet.__init__(self, ctb, body)
  290.         if body is not None:
  291.             self.fmode = self.body.read(1)
  292.             fnlen = self.body.read(1)
  293.             self.fname = self.body.read(fnlen)
  294.             self.ftime = self.body.read(4)
  295.         
  296.  
  297.  
  298.  
  299. class compressed_packet(packet):
  300.     
  301.     def __init__(self, ctb, stream):
  302.         packet.__init__(self, ctb, '')
  303.         if body is not None:
  304.             self.algo = stream.read(1)
  305.             self.data = stream.read()
  306.         
  307.  
  308.     
  309.     def validate(self):
  310.         return self.algo == '\x01'
  311.  
  312.     
  313.     def uncompress(self):
  314.         import zlib as zlib
  315.         decomp = zlib.decompressobj(-13)
  316.         stream = StringIO(decomp.decompress(self.data))
  317.         return stream
  318.  
  319.  
  320. _FACTORY = {
  321.     1: pke_packet,
  322.     2: signature_packet,
  323.     5: private_key_packet,
  324.     6: public_key_packet,
  325.     9: cke_packet,
  326.     11: literal_packet,
  327.     12: trust_packet,
  328.     13: userid_packet,
  329.     14: comment_packet,
  330.     pke_packet: 1,
  331.     signature_packet: 2,
  332.     private_key_packet: 5,
  333.     public_key_packet: 6,
  334.     cke_packet: 9,
  335.     literal_packet: 11,
  336.     trust_packet: 12,
  337.     userid_packet: 13,
  338.     comment_packet: 14 }
  339.  
  340. class packet_stream:
  341.     
  342.     def __init__(self, input):
  343.         self.stream = input
  344.         self.under_current = None
  345.         self._count = 0
  346.  
  347.     
  348.     def close(self):
  349.         self.stream.close()
  350.         if self.under_current is not None:
  351.             self.under_current.close()
  352.         
  353.  
  354.     
  355.     def read(self, keep_trying = 0):
  356.         while None:
  357.             ctb0 = self.stream.read(1)
  358.             if not ctb0:
  359.                 return None
  360.             
  361.             ctb = ord(ctb0)
  362.             if is_ctb(ctb):
  363.                 break
  364.                 continue
  365.             if keep_trying:
  366.                 continue
  367.                 continue
  368.             raise XXXError
  369.             continue
  370.             ctbt = (ctb & 60) >> 2
  371.             if ctbt == CTB_COMPRESSED_DATA:
  372.                 self.under_current = self.stream
  373.                 cp = compressed_packet(ctb0, self.stream)
  374.                 self.stream = cp.uncompress()
  375.                 return self.read()
  376.             
  377.         llf = ctb & 3
  378.         if llf == 0:
  379.             lenf = ord(self.stream.read(1))
  380.         elif llf == 1:
  381.             lenf = struct.unpack('>H', self.stream.read(2))[0]
  382.         elif llf == 2:
  383.             lenf = struct.unpack('>L', self.stream.read(4))[0]
  384.         else:
  385.             raise XXXError, 'impossible case'
  386.         body = self.stream.read(lenf)
  387.         if not body or len(body) != lenf:
  388.             raise XXXError, 'corrupted packet'
  389.         
  390.         self._count = self.stream.tell()
  391.         
  392.         try:
  393.             return _FACTORY[ctbt](ctb0, body)
  394.         except KeyError:
  395.             return packet(ctb0, body)
  396.  
  397.  
  398.     
  399.     def count(self):
  400.         return self._count
  401.  
  402.  
  403.  
  404. def is_ctb(ctb):
  405.     return ctb & 192
  406.  
  407.  
  408. def make_ctb(value, llf):
  409.     return chr(128 | value << 2 | llf)
  410.  
  411.